Lake District Overshot Waterwheel Project
Review and Analysis

Last update: 25 Nov 2023

Note

Last update: 28 Nov 2023
This page is a test post. The Jupyter notebook is a rough draft. So far I like how Quarto renders JupyterLab notebooks to HTML. This post is for testing only. Grammar and spelling checks have not been done.

Abstract

This notebook examines the design of a small hydroelectric water wheel built by Kris Harbour Natural Building. The water wheel is a 2.1 meter diameter wheel and he expected to generate between 1.5 and 1.7 kW. The project is documented in four YouTube videos, links are here: Part 1, Part 2, Part 3 and Part 4. The videos provide some technical details, but not enough to satisfy me. My JupyterLab notebook will cover the project description, the water wheel design, generator, flume, inverter and other topics he did not address such as instrumentation, safety, maintenance, reliability and economics.

Introduction

This notebook will review a few technical aspects of the project. I’ll try not to be too much of an armchair quarterback, or provide minute by minute commentary, since Kris does a good job of stating his frustrations as he narrates his videos. Over all, this is a very interesting project. The craftmanship and construction of the water wheel is very good. I think most of the issues are with other aspects of the project.

The important technical aspects for the water wheel, gear box and generator have been summarized in the table below:

Parameter	Value	Notes
Wheel diameter	2.1 meters	Part 1 @ 0:35
Wheel width	0.8 meters	same as flume
Bucket volume	48 liters	Part 1 @ 27:10
Number of Buckets	16	Part 1 @ 19:50
Flume length	8 meters	project survey document
Flume drop	0.3 meters	project survey document
Flume width	0.8 meters	project survey document
Flow rate	70 to 120 liters/sec	project survey document
Gear box	1:20 + 1:2 belt	total 1:40
Induction generator	2.2kw, 8 pole, 750 rpm	final video

In part 4 of his video, Kris shared some details of his orginal project survey. I captured images from the video and used google docs to convert the shreenshots to text. This document, converted to a pdf, can be viewed here: project survey dated 16/02/23

Review of videos

Each of the videos is about 40 minutes long. While watching, I took notes whenever he gave any technical details. The videos primarily document the build, installationa and some of the testing of the water wheel. The construction of the dam and flume were performed by others. Most of the testing he did on site after installation. The exception was some open circuit testing of the first generator in his workshop, which at the time, he thought was adequate.

Powering An Old Mill - 1.5 Kw Lake District Overshot Waterwheel Project Part 1

• 2.1m waterwheel
• 150 lps max flow rate
• 50 liter buckets, three per second = 150 lps -> 11.25 rpm
• gear reduction 20:1, wheel will do 12 to 16 rpm
• 500 rpm 2Kw, PM alternator
• flow 150 liters/sec maximum
  
• 50 liter buckets
  
• 3 buckets will pass per second
  
• 1.5 to 1.7 kW
  
• 20:1 gear reduction
  
• between 12 and 16 rpm depending on flow rate
  
• 500 rpm 2kW PM alternator <- 25 rpm at the waterwheel shaft this seems in conflict
  
• rpm of 16, rotation of 3.7 sec, 230 V from rectifer open circuit
  
• 16 buckets
  
• 42 L per bucket, measured 45 L

Powering An Old Mill - 1.5 Kw Lake District Overshot Waterwheel Project Part 2

• at the site no dam or pond, just the leat
• blocked the water, made some templates and models
• flume = four boards across, walls are set internal and look a bit higher than the individual base boards are wide @1:57
• work on the spill way
• @ 10:16 cutting back the flume
• @25:11 connected 3 conductors to bottom of the frame.
• 1st test 130 volts at low rpm and flow rate, then 340 volts w/o load
  
• @32:03 load test, maybe 1 inch of flow in the flume, buckets are lessthan, half flow making 530 Watts, time @33:08
• increased flow, maybe 1 inch in the flume
• @34:42 2nd day of testing, rained overnight and lots of water flowing around the wheel.
• @36:37 2/3rd flow, flume water level looks at the top at the enterence, but just past the gate, the water level is a few inches, reduced to like 1/2 up the side boards, buckets are ??, power 940 Watts
  
• @37:22 3rd day, showing the conduet installed
  
• complaning that the controller is letting the wheel spin too fast, but generating 1 kW
• @40:16 add some plywood to control the water fill angle, took some slow motion video @41:38.
  
• @42:54 put the controller into constant voltage mode 100V an di splanning to up the voltage based on testing
• wheel spinning much slower, buckets look 1/3 full @44:21
• He thinks the alternator want to spin much faster, it will generate 1000 Watts, but the wheel is spinning too fast, when he uses the controller to slow the wheel for proper bucket filling the power is much less and the alternater got very hot.

Powering An Old Mill - 1.5 Kw Lake District Overshot Waterwheel Project Part 3

• got a bigger pulley, now the total ratio is 20x2=40
• corner on the flume was improved
  
• Kris built a nozzle for the water
• @9:21 installed the new pulley and a new lower voltage alternater
• @14:11 with flume nozzle buckets look like they are filling better, look about 1/2 full, generater is making 420 Watts
  
• water flow from the main river down a man made leet,
• @16:22 removed the boards that made a temporary dam and much more water is flowing, but the wheel is spinning too fast but making 1160 Watts, earlier 1400 Watts
• 2 KW alternater, but only can make 1400 Watts before it gets too hot.
• @17:21 810 Watts when flow rate reduced and wheel spinning at a near proper speed.
• @18:33 next day, ran all night, making 750 Watts
• @19:19 600 rpm on the generator (15 rpm on the water wheel), measured with a Tach, generating Alt temp is 80C when generating 750 Watts (that 15 rpm on the wheel shaft)
• @22:46 950 Watts is the most it can do before it gets too hot
• test grid down dump load.
• @34:41 took apart the 220 V alternator and the new one is a 96V alternator.
• @42:30 new plan is to use amn 8 pole induction motor

Why did he change to a lower voltage alternater? Old alternater was making 420 volts, he wanted 220 volts.

Powering An Old Mill 1.5 Kw Lake District Overshot Waterwheel Project Part 4

• 3 phase induction motor, 8 pole, 750 rpm, 2.2kW (needs a water wheel speed of 18.75 rpm)
  
• motor face plate: Tec ECHTOP UK CA, Type 2283TECA 83
  
• switched to a 2kW induction motor, 728rpm, 1711 Watts, 184 volts
  
• testing of induction motor in John’s hydro electric workshop, drive motor was 3kW, 728rpm, 1711 Watts, 184 volts, 80uF caps
  
• modifiling the frame and mounting brackets
  
• looks like a cooling fan on the back of the motor, water side.
  
• added emergency shut off flap
  
• dump load mounted on wall in poarch, 1.5 kW load
  
• half flow test made 860W
  
• full flow entrance to flume is at the top of the walls, but within everal inches the depth is 1/2, at the end of the flume, depth looks loke 1 inch,
  
• full flow, water is impacking into the buckets with substantial splash over, generating about 1.6kW, splasing on the generator cover, at the 4 to 5 oclock postion, water sloshing out of the buckets, buckest are 2/3s full, making 1350 Watts
  
• added plywood to block water exit from the leat in order to increase the flow
  
• flow in the flume looks a bit larger, maybe 2 inches deep at the exit, pitch on the flume looks like a couple of inches, velocity is high, lots of spash over, making 1500 to 1550 Watts, promised the customer 1500 Watts - not a qualified electrician, only doing the mechanicans and making electricity.
• changing the caps to smaller value
  
• with some reduced flow, getting 1150 Watts, but less splashing,
  
• @22.33 Kris shows orginal project survey dated 16/02/23, link to OCR of screen captures.
• added a rpm sensor to run a safety shut off
  
• at time 29:41 with minimal splasing generates about 500 Watts
  
• testing with gride off, power dumped into load, resistors shown at 50C

Units

In the calculations that follow, I’m using the Python package, Pint, which allows mathematical operations with units and conversions to and from different units. Keeping track of the units will provide some error checking when performing the calculations. I’ll be using metric units since these are what Kris has been using. All calculations are done using the International System of units. A list of units and conversions used by Pint is here.

Variables and constants

There are a couple of variables and constants that will be used throughout the calculations.

• Q is used for flow rate
  
• tau or \(\tau\) is used for torque
• omega or \(\omega\) is used for angular velocity
• g is used to denote the gravity of Earth, standard gravity by definition is equal to 9.80665 \(m/s^2\)
• rho or \(\rho\) is used for the density of water, at 50F or 10C is 999.75 \(kg/m^3\)
• eta or \(\eta\) is used for energy conversion efficiency, accounts for the energy lost to heat

I’ll be using descriptive names for the variable used in my calculations.

Code

import pint
ureg = pint.UnitRegistry()
import numpy as np
from tabulate import tabulate
import matplotlib.pyplot as plt

Code

ureg = pint.UnitRegistry(autoconvert_offset_to_baseunit = True)

Code

g = 9.80665*ureg.meter/(ureg.sec**2) # standard gravity
rho = 999.75*ureg.kg/(ureg.meter**3) # density of water at 50F or 10C, kg/m^3

Terminology

Kris uses the term ‘trough’ for the structure that carries the water to the top of the water wheel; I’ll be using the term Flume to describe the structure.

Other terms are:

• Mill race
  
• Mill pond
  
• Leat
  
• Sluice
  
• Weir
  
• Pico hydro
• Grid-tied electrical system

Gravitational power of water

The harvesting of the gravitational energy of water is a proven source of energy. Since a waterwheel is used to extract power from the water, the head height is approximately the diameter of the waterwheel. Water enters at the top of the wheel and the weight of the water causes the wheel to rotate until a point near the bottom of the wheel. So let’s use the diameter of the waterwheel.

The gravitational power of water is given by:

\(P = \rho \times g \times Q \times H\)

where:
P = gravitational power of water
H = height of fall Q = flow rate
g = acceleration due to gravity
\(\rho\) = density of water

Checking Kris’ calculations

Kris provided his customer an estimated of the power that might be generated versus flow rates. The following table is from his project survey. Kris used H = 2.6 meters and \(\eta\) of 0.6.

Kris’s estimated power, head = 2.6 meters, \(\eta\) = 60%

Flow rate	Power, Watts
60 lps	833
70 lps	1,030
80 lps	1,177
90 lps	1,324
100 lps	1,472
110 lps	1,619
116 lps	1,692

My power calculations are shown below.

H = 2.6ureg.meter eta = 0.6 Q = np.array([60,70,80,90,100,110,116])ureg.liter/(1ureg.sec) print(‘head height: {:.1fP}, 3B7: {:.1f}’.format(H,eta)) print(‘{:<15s}{:<10s}’.format(‘Flow rate’, ‘power’)) for i in Q: print(‘{:<3.0f~P} {:<,.1f~P}’.format(i.to(‘l/s’),(rhogiH*eta).to(‘watts’)))

Code

H = 2.6*ureg.meter
eta = 0.6
Q = np.array([60,70,80,90,100,110,116])*ureg.liter/(1*ureg.sec)
print('head height: {:.1fP}, \u03B7: {:.1f}'.format(H,eta))
table_header = ['Flow rate, lps', 'power, W']
table_row = []

for i in Q:
    table_row.append([i.to('l/s').magnitude,(rho*g*i*H*eta).to('watts').magnitude])

print(tabulate(table_row, headers=table_header,tablefmt="simple",floatfmt=('.0f',',.1f')))

head height: 2.6 meter, η: 0.6
  Flow rate, lps    power, W
----------------  ----------
              60       917.7
              70     1,070.6
              80     1,223.6
              90     1,376.5
             100     1,529.5
             110     1,682.4
             116     1,774.2

My numbers don’t match Kris’s numbers, which he presented in his project survey. Also, seems courious that the final number in his table is 116 lps and not 120 lps.

Case studies

The history of water wheels dates back thousands of years and the fundementals of water wheels are well understood. What is new is the restoration of historic water mills being employed to generate electricity. Water wheels have a low rotational speed with high torque and this equires the use of gears to step up the rotational speed to a level that can be used by electrical generators. I found two intreseting examples of small water wheels being used to generate electrical power. In each of these examples, we can calculate the overall efficiency. This is a useful data point since these water wheels are of simular size to the one Kris built.

Eskdale Mill
The Eskdale Mill is profiled in the YouTube video (link above). Smith Engineering performed the design of the water wheel. The wheel is installed at the oldest and last working corn mill in the English Lake District, providing power for the miller’s cottage. It has been positioned adjacent to the Grade II* listed mill which has been operating for hundreds of years. It is now owned and run as a tourist attraction by Eskdale Mill & Heritage Trust, a charity run by local people, who will gain a supplementary income from the power generated to cover some of the mill’s overheads and maintenance costs.

Eskdale Mill, miller’s cottage water wheel summary

Location	Boot, Eskdale Valley, Cumbria, England
Commissioned	July 2016
Output	3.5 kW
Flow rate	120 l/s
Wheel diameter	4.0 m
Wheel width	0.8 m
Gearbox	Brevini epicyclic
Generator	Brook Crompton three-phase, 415V induction motor converted to single-phase 240V

The power and efficiency is calculated below.

Code

H = 4*ureg.meter # diemater of the wheel, used as the head height
Q = 120*ureg.liter/(1*ureg.sec)
print('available power: {:,.1fP}'.format((rho*g*Q*H).to('watts')))
print('efficiency: {:,.2f}%'.format(((3500*ureg.W)/(rho*g*Q*H).to('watts')).magnitude*100))

available power: 4,706.0 watt
efficiency: 74.37%

The Langdale Hotel and Spa, English Lake District
This water wheel was also build by Smith Engineering and based on research and development that Smith Engineering had undertaken with Dr Paddy Quinlan of the University of Cumbria on bucket design and efficiency. There is a high degree fo simularity in the look of this water wheel to the one that Kris built.

The Langdale Hotel and Spa water sheel summary

Location	Great Langdale, Cumbria, England
Commissioned	November 2014
Output	6 kW
Flow rate	200 l/s
Wheel diameter	4.1 m
Wheel width	1 m
Gearbox	Brevini epicyclic 177:1 ratio
Generator	Brook Crompton three-phase, 415V induction motor, power rating of 11kW

Code

H = 4.1*ureg.meter
Q = 200*ureg.liter/(1*ureg.sec)
(rho*g*Q*H).to('watts')
print('available power: {:,.1fP}'.format((rho*g*Q*H).to('watts')))
print('efficiency: {:,.2f}%'.format(((6000*ureg.W)/(rho*g*Q*H).to('watts')).magnitude*100))
print('generator rated power to avaliable power: {:,.2f}'.format(((11000*ureg.W)/(rho*g*Q*H).to('watts')).magnitude))

available power: 8,039.4 watt
efficiency: 74.63%
generator rated power to avaliable power: 1.37

Links to other water wheel videos:

• Hydro electric water wheel with generator in Egloffstein: A hydro-electric water wheel in Egloffstein Franconia with 12kW Generator.
  
• Stunning Franconia Aerial #6 Hydro electric water wheel in Egloffstein; The camera is flying over a hydro-electric water wheel in Egloffstein, Franconia (Germany).
  
• Two views of the 1926 Fitz overshot waterwheel at Hanford Mills Museum: Two views of the 1926 Fitz Overshot waterwheel in operation at Hanford Mills Museum in East Meredith, NY. The power generated is used to run the sawmill and woodworking machines. The first view is from the visitor platform, and the second is from the tail race. The 10-foot diameter waterwheel is 12 feet wide. A system of belts, pulleys and gears transfers the power to machines upstairs in the Mill.
  
• Waterwheel power 4kW to grid: We re-purposed this 140 year old wheel to generate and export power back to the grid in 2007/8. 10 years on and its made well over 100,000kWh energy, most of it exported .. generation matches flow availability, we could process more but the axles at its limit and the wheel floods .. efficiency is very high, the gearbox and generator silent, its a capacitor excited induction generator with integral flow management and grid tie cabinet. The system hinges around the ponds water level, the original wheel control sluice is reused. This is a beautifully engineered large wheel running well within its capabilities, the iron structure is much more than functional, a look in detail shows considerable artisan and design skills … we believe this is the largest wheel on a domestic property in UK Update 2019/20: still working really, really well. New owner, Francis, has addressed a number of site issues and runs at full rated power most of the time. we’re well on the way to the first 500,000 kWh energy production.
  
• Water wheel - Energy Power Generator - Construction KIT: Water wheel - Upper bucket - Building kit. We offer a complete building kit or just drawings for the CNC production of a water wheel type - Upper bucket. The material for production is stainless steel or ordinary steel. It is possible to change the dimensions as required. The water wheel is a suitable water engine for all historic buildings, such as a power plant or as decoration. At reduced speeds, it can process many times smaller flows than expected, without a decrease in efficiency.

Some take aways:

• in most cases, the water velocity in the flume seems low and there is not a lot of splashing
• the rated power of the generator is usially higher than the avaliable power

Project analysis

The analysis of the project will consist of looking at the performance of the water wheel based on the information avaliable from the four YouTube videos. In the calculations that follow, the head height is the same as the water wheel diameter.

Code

H = 2.1*ureg.meter # head equal to the wheel diameter
print('head height: {:.1f#~P}'.format(H))

head height: 2.1 m

Kris use an overall efficieny of 60% in his calculations. I’ve decided to break out the efficiencies of the major parts and then calculate an overall efficiency.

Efficiencies

A typical overshot Water wheel has the water channeled to the wheel at the top and slightly beyond the axle. The water collects in the buckets on that side of the wheel, making it heavier than the other “empty” side. The weight turns the wheel and the water flows out into the tail-water when the wheel rotates enough to invert the buckets. The overshot design can achieve 90% efficiency. Nearly all of the energy is gained from the weight of water lowered to the tailrace although a small contribution may be made by the kinetic energy of the water entering the wheel.

The efficiencies I’ll be using in my calculations:

• \(\eta\) for waterwheel = 90%
  
• \(\eta\) for gear box = 95%
  
• \(\eta\) for generator = 90%
• \(\eta\) for grid-tie inverter = 97%

These effencienies have been adjusted to give an overall efficiency in line with what has been acheived in the case studies.

Code

eta_waterwheel = 0.9 # for a small waterwheel
eta_gear_box = 0.95
eta_generator = 0.9
eta_grid_tie_inverter = 0.97
eta_total = eta_waterwheel*eta_gear_box*eta_generator*eta_grid_tie_inverter
print('total efficiency: {:.3f}'.format(eta_total))

total efficiency: 0.746

Design parameters

In the YouTube video and the project survey, Kris stated that the veritcal height that was available down stream from the dam would allow for a 2.1 meter diameter water wheel with some room clearace above and below. The flume would need to be about 8 meters long. The flow rate avalailbe ranged from 60 to 120 liters per second (lps or l/s) and that the goal was to generate 1,500 Watts, presummably at 120 lps.

Design parameters

avaliable vertical height for wheel	2.1 meters
water flow rate	60 to 120 lps
flume length	8 meters
objective generated power out	1500W at 120 lps

I’ve decided to include a design marging of 15% in the power estimate calculation to account for unknowns and poor estimates.

Code

design_margin = 0.15

The gravitation power of water at various flow rates is plotted below.

Code

step_size = 20
Q = np.arange(60, 180+step_size, step_size)*ureg.liter/(1*ureg.sec)

plt.plot(Q.to('liter per sec').magnitude,(rho*g*Q*H*eta_total*(1-design_margin)).to('watts').magnitude,'-k')
plt.grid()

#plt.ylim((0,10))
plt.ylabel('power , Watts')
plt.xlabel('flow rate, l/s')

plt.title('Gravitational power of water, head height: {:.1fP}, \u03B7: {:.3f}'.format(H,eta_total))

plt.show()

This data is dispayed in the table below:

print(‘head height: {:.1fP}, 3B7: {:.3f}, design margin: {:.2f}’.format(H,eta_total,design_margin)) print(‘{:<15s}{:<10s}’.format(‘Flow rate’, ‘power’)) for i in Q: print(‘{:<3.0f~P} {:<,.1f~P}’.format(i.to(‘l/s’),(rhogiHeta_total*(1-design_margin)).to(‘watts’)))

Code

#H = 2.6*ureg.meter
#eta = 0.6
#Q = np.array([60,70,80,90,100,110,116])*ureg.liter/(1*ureg.sec)
print('head height: {:.1fP}, \u03B7: {:.1f}'.format(H,eta))
table_header = ['Flow rate, lps', 'power, W']
table_row = []

for i in Q:
    table_row.append([i.to('l/s').magnitude,(rho*g*i*H*eta_total*(1-design_margin)).to('watts').magnitude])

print(tabulate(table_row, headers=table_header,tablefmt="simple",floatfmt=('.0f',',.1f')))

head height: 2.1 meter, η: 0.6
  Flow rate, lps    power, W
----------------  ----------
              60       783.8
              80     1,045.0
             100     1,306.3
             120     1,567.5
             140     1,828.8
             160     2,090.0
             180     2,351.3

Code

print('With in the flow rate range of {:.0f~P} to {:.0f~P}, \nthe estimated power avaliable is {:.1f~P} to {:.1f~P}.'.format(Q[0],Q[-1],(rho*g*Q[0]*H*eta_total*(1-design_margin)).to('watts'),(rho*g*Q[-1]*H*eta_total*(1-design_margin)).to('watts')))

With in the flow rate range of 60 l/s to 180 l/s, 
the estimated power avaliable is 783.8 W to 2351.3 W.

Looks like making 1500 W at 120 lps is feasable.

Instrumentation

Kris utilized only a volt meter and relied on the inverter to provide him an indication of the power being generated. For testing, he should have used a resistive load, a volt meter (which he did use) and an amp meter. He could have used the dump load across the three phase recitfier. This would have eliminated any setup issues with the inverter.

Electrical load for testing

In the videos, Kris was using inverter as the electrical load for the generator. I think he should have been using a high power resistive load for his inital tests. Three portable electric heater or his dump load could have been used for testing. Once everything was sorted out, he could then connect to the inverter for additional tests.

To calculate the load resistance for testing, I’m assuming that 1500 Watts is the load he should be using; I’m also assuming the geneator makes 220 volts at the rate power at 500 RPM.

Kris didn’t say too much about the inverter, except that he was able to control the speed of the wheel by changing the mode to constant voltage and setting the value to 100 volts. This casued the genrator to get too hot under full flow conditions. About this time he started to suspect that the rating of the generator was much less than advertised. But the situations is a little confusing. I suspect that the availavle power was much greater than the power indicated on the inverter display, so the difference was being dissipated as heat in the generator, since the generator was being forced to provide a breaking load to the water wheel. This is why using a fixed power resistor as the load would have been much better for inital testing.

Code

print('current delivered to test load: {:.1f~P}'.format((1500*ureg.watt/(220*ureg.volt)).to_base_units()))

R_load = (1500*ureg.watt/((1500*ureg.watt/(220*ureg.volt))**2)).to('ohms')
print('resistance of test load: {:.1f~P}'.format(R_load))

current delivered to test load: 6.8 A
resistance of test load: 32.3 Ω

Generator voltage vs RPM

I’m going to assum that the generator’s output voltage is linear with respect to the generator shaft rotational speed (at least over the normal operating RPM range). In the videos, Kris used several generators. The first one appears to have a rated voltage of 220 Volts. Later this generator was swapped out for one with a lower voltage rating of 96 Volts. In the final video, Kris changes the generator to an induction motor.

• didn’t explain why he changed from 220 to 96 volts except to say he was concerned that the wheel was spinning too fast.
• The initial design had the 220 Volt generator, so that’s what I’m going with for the initial part of the analysis, later I’ll address the generator questions.

Code

water_wheel_rotation_frequency = (np.arange(5,16))*ureg.rpm
gear_box = 40
gen_voltage = ((220/500)*water_wheel_rotation_frequency.magnitude*gear_box)*ureg.volt

plt.plot(water_wheel_rotation_frequency.magnitude,gen_voltage.to('volt').magnitude, '-')

plt.grid()

plt.ylabel('generator out put, volts')
plt.xlabel('water wheel RPM')

plt.title('generator output voltage')
plt.show()

Later, I’ll look at power flow through the hydo system. Power from gravity on the mass of the water, to the rotational power of the wheel (RPM x torque), to the genrator and finally to the electrical test load. Accounting for losses along the way, the power delivered to the electrical load should be equal to the rotational power of the wheel minus the losses.

Water wheel

The water wheel the Kris designed and fabricated has a diameter of 2.1 meters, 16 buckets, each with a capacity of 48 liters and the wheel width is 0.8 meters. In the calculations that follow, I’m assuming the wheel will have a rotational frequency of between 5 to 15 rotations per minute (rpm). The electrical load on the generator will limit the rotational frequency of the water wheel by resisting the torque delivered to the generator shaft. The electrical load is provided by the inverter. Through out the calculations that follow, I’m assuming that the wheel rotation frequency will be limited by the electrical load placed on the generator by the inverter. If the wheel is making 1000 Watts and delivering this power to the generator shaft, it is assumed that the generator will extract the power at an RPM within the range of 5 to 15 RPM based on the action of the inverter.

There are 16 buckets, each with a capacity of 48 liters. I’ll assum that the buckets will fill to a level of 95% of the bucket volumn. However, Kris stated in his video, that he though the bucket capacity was more like 50 liters because of the side wall of the wheel frame. In all the water wheels that I have observed on various YouTube videos, the buckets don’t fill to 100%.

Code

number_of_buckets = 16/(1*ureg.circle)
wheel_width = 0.8*ureg.meter
bucket_volume = 48*ureg.liter
water_wheel_diameter = 2.1*ureg.meter

bucket_capacity_utilization = 0.95

water_wheel_rotation_frequency = (np.arange(5,16))*ureg.rpm

Water carring capacity vs rpm

For a give rpm and fill level, the water wheel can move a fixed amount of water. The water carring capacity is calculated by taking the rotation frequency times the number if buckets times the bucket capacity utilization. The Python pint library keeps track of the units. The number of buckets has the dimention of 16 per circle, so the product of the terms has dimentions that can be converted to liters per second.

The water wheel carring capacity at various flow rates is plotted below.

Code

plt.plot(water_wheel_rotation_frequency.magnitude,(water_wheel_rotation_frequency*number_of_buckets*bucket_volume*bucket_capacity_utilization).to('liter/sec').magnitude, '-')

plt.grid()

plt.ylabel('water carring capacity, l/s')
plt.xlabel('wheel RPM')

plt.title('water carring capacity, buckets are {:.0f}% full'.format(bucket_capacity_utilization*100))
plt.show()

The wheel carring capacity versus wheel RPM is tabulated below.

print(‘{:<15s}{:<10s}’.format(‘wheel rpm’, ‘water carring capacity’)) for i in water_wheel_rotation_frequency: print(‘{:<4.1f~P} {:<,.1f~P}’.format(i.to(‘rpm’),(inumber_of_bucketsbucket_volume*bucket_capacity_utilization).to(‘liter/sec’)))

Code

table_header = ['wheel rpm', 'water carring capacity, lps']
table_row = []

for i in water_wheel_rotation_frequency:
    table_row.append([i.to('rpm').magnitude,(i*number_of_buckets*bucket_volume*bucket_capacity_utilization).to('liter/sec').magnitude])

print(tabulate(table_row, headers=table_header,tablefmt="simple",floatfmt=('.0f',',.1f')))

  wheel rpm    water carring capacity, lps
-----------  -----------------------------
          5                           60.8
          6                           73.0
          7                           85.1
          8                           97.3
          9                          109.4
         10                          121.6
         11                          133.8
         12                          145.9
         13                          158.1
         14                          170.2
         15                          182.4

At 10 RPM, the wheel can move at most 121 lps. At higher flow rates, the excess water will over flow the buckets and not contribute any additional weight to the bucket.

Water wheel torque vs rpm

The force that turns the wheel is provided by gravity and the mass of the water. Only about half of the buchets on one side of the wheel are filled with water and the weight imbalance causes the wheel to turn under the force of gravity.

calculations

moment arm

Torque

units

Let’s assume that half of the buckets have water. Assume 95% bucket capacity utilization.

\(\large{\color {red} {\text{clean up narrative}}}\)

need to convert the above to units of pound force

The pound of force or pound-force (symbol: lbf,[1] sometimes lbf,[2]) is a unit of force used in some systems of measurement, including English Engineering units[a] and the foot–pound–second system.[3]

Pound (force)
The pound of force or pound-force (symbol: lbf,[1] sometimes lbf,[2]) is a unit of force used in some systems of measurement, including English Engineering units[a] and the foot–pound–second system.[3]

Pound-force should not be confused with pound-mass (lb), often simply called “pound”, which is a unit of mass; nor should these be confused with foot-pound (ft⋅lbf), a unit of energy, or pound-foot (lbf⋅ft), a unit of torque.

the meter-kilogram-second gravitational unit of work and energy equal to the work done by a kilogram force acting through a distance of one meter in the direction of the force : about 7.235 foot-pounds

Torque Torque has the dimension of force times distance, symbolically T−2L2M. Although those fundamental dimensions are the same as that for energy or work, official SI literature suggests using the unit newton-metre (N⋅m) and never the joule.[12][13] The unit newton-metre is properly denoted N⋅m.[13]

The traditional imperial and U.S. customary units for torque are the pound foot (lbf-ft), or for small values the pound inch (lbf-in). In the US, torque is most commonly referred to as the foot-pound (denoted as either lb-ft or ft-lb) and the inch-pound (denoted as in-lb).[14][15] Practitioners depend on context and the hyphen in the abbreviation to know that these refer to torque and not to energy or moment of mass (as the symbolism ft-lb would properly imply).

Newton (unit)
The newton (symbol: N) is the unit of force in the International System of Units (SI). It is defined as 1 kg ⋅ m/s 2 { {}^{2}}, the force which gives a mass of 1 kilogram an acceleration of 1 metre per second per second. It is named after Isaac Newton in recognition of his work on classical mechanics, specifically his second law of motion.

A newton is defined as 1 kg ⋅ m/s 2 { {}^{2}} (it is a derived unit which is defined in terms of the SI base units).[1] One newton is, therefore, the force needed to accelerate one kilogram of mass at the rate of one metre per second squared in the direction of the applied force.[2]

The plot above says that at 10 rpm, 116.89 lps of water can be moved with buckets at 90% full.

Make a new plot, don’t assum the buckets are full. For example at 200 lps and 15 rpm, what is the torque?

Code

x = np.linspace(0, np.pi,int(number_of_buckets.magnitude/2))
moment_arm = (water_wheel_diameter/2)*np.sin(x)

Code

# do the calculations from 5 to 20 rpm using 100 points
water_wheel_rotation_frequency = (np.linspace(5,20,100))*ureg.rpm

for i in range(len(Q)):  # use the same flow rate from above
    #water_capacity_per_rotation = number_of_buckets*bucket_volume
    water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))*ureg.kilogram*ureg.g0*ureg.meter

    for j in range(len(water_wheel_rotation_frequency)):
        water_transport_rate = (number_of_buckets*bucket_volume*water_wheel_rotation_frequency[j]).to('liter/sec')

        bucket_capacity_utilization = Q[i]/water_transport_rate

        # limit transport rate to flow rate
        if bucket_capacity_utilization > 1:
            bucket_capacity_utilization = 1
            water_transport_rate = Q[i]

        weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization

        torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
        water_wheel_shaft_torque[j] = torque_per_bucket.sum()    

    plt.plot(water_wheel_rotation_frequency.magnitude,water_wheel_shaft_torque.to('N m').magnitude,'-',label='{:.1f~P}'.format(Q[i]))

plt.grid()

plt.ylabel('water wheel shaft torque, N m')
plt.xlabel('wheel rpm')

plt.title('new plot')
plt.legend(loc=0)

plt.show()

what does this say??

\(\large{\color {red} {\text{clean up narrative}}}\)

gen_shaft_rotation_freq = np.array([125,250,500,1000])ureg.rpm/50 gen_pwr = np.array([0.5,1,2,4])1000*ureg.watts gen_pwr

gen_shaft_rotation_freq

gen_pwr

water_wheel_rotation_frequency

Code

for i in range(len(Q)):
    #water_capacity_per_rotation = number_of_buckets*bucket_volume
    water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))*ureg.kilogram*ureg.g0*ureg.meter

    for j in range(len(water_wheel_rotation_frequency)):
        water_transport_rate = (number_of_buckets*bucket_volume*water_wheel_rotation_frequency[j]).to('liter/sec')

        bucket_capacity_utilization = Q[i]/water_transport_rate

        # limit transport rate to flow rate
        if bucket_capacity_utilization > 1:
            bucket_capacity_utilization = 1
            water_transport_rate = Q[i]

        weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization

        torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
        water_wheel_shaft_torque[j] = torque_per_bucket.sum()    

    plt.plot(water_wheel_rotation_frequency.magnitude,(water_wheel_shaft_torque*water_wheel_rotation_frequency*eta_waterwheel).to('watts').magnitude,'-',label='{:.1f~P}'.format(Q[i]))

#plt.plot(gen_shaft_rotation_freq.magnitude,gen_pwr.magnitude,'.k',label='{:.1f~P}'.format(Q[i]))

plt.grid()

plt.ylabel('water wheel shaft power, Watts')
plt.xlabel('wheel rpm')

plt.title('new plot')
plt.legend(loc=1)

plt.show()

what does this say?

If the controller tries to keep the wheel rpm around 10, then the generator needs to absorb between 1000 and 2200 Watts

at flow rates of 180 lps and above the power levels off at 3kW, so the generator should be sized to higher than 3kW

Print data as a table

R_load

water_wheel_rotation_frequency = (np.arange(5,21))*ureg.rpm

i = 3 #for i in range(len(Q)):

print(‘{:>10s} {:>10s} {:>10s} {:>20s} {:>15s} {:>20s} {:>20s}’.format(‘flow, lps’,‘rpm’,‘torque’,‘avaliable pwr, W’,‘gen voltage’,‘Amps to the load’,‘pwr to the load’))

#water_capacity_per_rotation = number_of_bucketsbucket_volume water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))ureg.kilogramureg.g0ureg.meter

for j in range(len(water_wheel_rotation_frequency)): water_transport_rate = (number_of_bucketsbucket_volumewater_wheel_rotation_frequency[j]).to(‘liter/sec’)

bucket_capacity_utilization = Q[i]/water_transport_rate

# limit transport rate to flow rate
if bucket_capacity_utilization > 1:
    bucket_capacity_utilization = 1
    water_transport_rate = Q[i]

weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization

torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
water_wheel_shaft_torque[j] = torque_per_bucket.sum()    

available_pwr = (water_wheel_shaft_torque[j]*water_wheel_rotation_frequency[j]*eta_waterwheel)
load_volts = (220/500)*water_wheel_rotation_frequency[j].magnitude*gear_box*ureg.volt
load_current = load_volts/R_load
load_pwr = R_load*load_current**2

print('{:>10.0f} {:>10.0f} {:>10.0f} {:>20.1f} {:>15.1f} {:>20.1f} {:>20.1f}'.format(Q[i].magnitude,
    water_wheel_rotation_frequency[j].magnitude,
    water_wheel_shaft_torque[j].to('N m').magnitude,
    available_pwr.to('watts').magnitude,
    load_volts.magnitude,
    load_current.magnitude,
    load_pwr.magnitude                                                                   
     ))

print(tabulate([[‘Alice’, 24], [‘Bob’, 19]], headers=[‘Name’, ‘Age’]))

Code

water_wheel_rotation_frequency = (np.arange(5,21))*ureg.rpm

i = 3 #for i in range(len(Q)):

#print('{:>10s} {:>10s} {:>10s} {:>20s} {:>15s} {:>20s} {:>20s}'.format('flow, lps','rpm','torque','avaliable pwr, W','gen voltage','Amps to the load','pwr to the load'))

table_header = ['flow','rpm','torque','avaliable pwr','gen voltage','load amps','load pwr']
table_row = []

#water_capacity_per_rotation = number_of_buckets*bucket_volume
water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))*ureg.kilogram*ureg.g0*ureg.meter

for j in range(len(water_wheel_rotation_frequency)):
    water_transport_rate = (number_of_buckets*bucket_volume*water_wheel_rotation_frequency[j]).to('liter/sec')

    bucket_capacity_utilization = Q[i]/water_transport_rate

    # limit transport rate to flow rate
    if bucket_capacity_utilization > 1:
        bucket_capacity_utilization = 1
        water_transport_rate = Q[i]

    weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization

    torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
    water_wheel_shaft_torque[j] = torque_per_bucket.sum()    

    available_pwr = (water_wheel_shaft_torque[j]*water_wheel_rotation_frequency[j]*eta_waterwheel)
    load_volts = (220/500)*water_wheel_rotation_frequency[j].magnitude*gear_box*ureg.volt
    load_current = load_volts/R_load
    load_pwr = R_load*load_current**2
    
    table_row.append(
            [Q[i].magnitude,
            water_wheel_rotation_frequency[j].magnitude,
            water_wheel_shaft_torque[j].to('N m').magnitude,
            available_pwr.to('watts').magnitude,
            load_volts.magnitude,
            load_current.magnitude,
            load_pwr.magnitude])                                                                   

print(tabulate(table_row, headers=table_header,tablefmt="simple",floatfmt=('.0f','.0f',',.1f',',.1f','.1f','.1f',',.1f')))

  flow    rpm    torque    avaliable pwr    gen voltage    load amps    load pwr
------  -----  --------  ---------------  -------------  -----------  ----------
   120      5   2,164.9          1,020.2           88.0          2.7       240.0
   120      6   2,164.9          1,224.2          105.6          3.3       345.6
   120      7   2,164.9          1,428.3          123.2          3.8       470.4
   120      8   2,164.9          1,632.3          140.8          4.4       614.4
   120      9   2,164.9          1,836.4          158.4          4.9       777.6
   120     10   2,029.6          1,912.9          176.0          5.5       960.0
   120     11   1,845.1          1,912.9          193.6          6.0     1,161.6
   120     12   1,691.4          1,912.9          211.2          6.5     1,382.4
   120     13   1,561.2          1,912.9          228.8          7.1     1,622.4
   120     14   1,449.7          1,912.9          246.4          7.6     1,881.6
   120     15   1,353.1          1,912.9          264.0          8.2     2,160.0
   120     16   1,268.5          1,912.9          281.6          8.7     2,457.6
   120     17   1,193.9          1,912.9          299.2          9.3     2,774.4
   120     18   1,127.6          1,912.9          316.8          9.8     3,110.4
   120     19   1,068.2          1,912.9          334.4         10.4     3,465.6
   120     20   1,014.8          1,912.9          352.0         10.9     3,840.0

Code

#water_wheel_rotation_frequency = (np.arange(5,21))*ureg.rpm
water_wheel_rotation_frequency = (np.linspace(5,20,100))*ureg.rpm
#i = 6 #for i in range(len(Q)):

water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))*ureg.kilogram*ureg.g0*ureg.meter
available_pwr = np.zeros(len(water_wheel_rotation_frequency))*ureg.watt
load_pwr = np.zeros(len(water_wheel_rotation_frequency))*ureg.watt

for j in range(len(water_wheel_rotation_frequency)):
    water_transport_rate = (number_of_buckets*bucket_volume*water_wheel_rotation_frequency[j]).to('liter/sec')

    bucket_capacity_utilization = Q[i]/water_transport_rate

    # limit transport rate to flow rate
    if bucket_capacity_utilization > 1:
        bucket_capacity_utilization = 1
        water_transport_rate = Q[i]

    weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization

    torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
    water_wheel_shaft_torque[j] = torque_per_bucket.sum()    

    available_pwr[j] = (water_wheel_shaft_torque[j]*water_wheel_rotation_frequency[j]*eta_waterwheel)
    load_volts = (220/500)*water_wheel_rotation_frequency[j].magnitude*gear_box*ureg.volt
    load_current = load_volts/R_load
    load_pwr[j] = R_load*load_current**2
    
plt.plot(water_wheel_rotation_frequency.magnitude,available_pwr.to('watts').magnitude,'-',label='available pwr')
plt.plot(water_wheel_rotation_frequency.magnitude,load_pwr.to('watts').magnitude,'-',label='load pwr')  

idx = np.argwhere(np.diff(np.sign(load_pwr.to('watts').magnitude - available_pwr.to('watts').magnitude))).flatten()
plt.plot(water_wheel_rotation_frequency.magnitude[idx],load_pwr.to('watts').magnitude[idx], 'ro')
plt.plot(water_wheel_rotation_frequency.magnitude[idx],available_pwr.to('watts').magnitude[idx], 'kx')

plt.grid()

plt.ylabel('power, Watts')
plt.xlabel('wheel rpm')

plt.title('available power from water wheel, power to R_load = {:.1f~P} @ flow = {:.1f~P}'.format(R_load,Q[i]))
plt.legend(loc=0)

plt.show()

print('the curves intersect at {:.1f} rpm and {:.1f} W'.format(float(water_wheel_rotation_frequency.magnitude[idx]),float(load_pwr.to('watts').magnitude[idx])))

the curves intersect at 14.1 rpm and 1906.1 W

• At 120 pls, the curves intersect at 14.1 rpm and 1906.1 W
• At 180 lps, the curves intersect at 17.3 rpm and 2864.1 W

Are the graphs below correct? what do they say?

Wheel tangential velocity vs RPM

Which to use rotation velocity or Angular velocity??

Rotational frequency, also known as rotational speed or rate of rotation (symbols ν, lowercase Greek nu, and also n), is the frequency of rotation of an object around an axis. Its SI unit is the reciprocal seconds (s−1); other common units of measurement include the hertz (Hz), cycles per second (cps), and revolutions per minute (rpm).

In physics, angular velocity (symbol ω or ω → {}, the lowercase Greek letter omega), also known as angular frequency vector,[1] is a pseudovector representation of how the angular position or orientation of an object changes with time, i.e. how quickly an object rotates (spins or revolves) around an axis of rotation and how fast the axis itself changes direction.

turn = 2 * π * radian = _ = revolution = cycle = circle

[frequency] = 1 / [time]
hertz = 1 / second = Hz
revolutions_per_minute = revolution / minute = rpm
revolutions_per_second = revolution / second = rps
counts_per_second = count / second = cps

The speed of the object traveling the circle is:

\(v=\frac {2\pi r}{T}=\omega r\)

v = tangential speed
r = radius
T = period for one rotation \(\omega\) = angular rate of rotation, also known as angular velocity

Tangential speed

\(v=r\omega\)

What is \(\omega\)?

In physics, angular velocity (symbol ω or ω → {}, the lowercase Greek letter omega), also known as angular frequency vector,[1] is a pseudovector representation of how the angular position or orientation of an object changes with time, i.e. how quickly an object rotates (spins or revolves) around an axis of rotation and how fast the axis itself changes direction.

Angular velocity has dimension of angle per unit time; this is analogous to linear velocity, with angle replacing distance, with time in common. The SI unit of angular velocity is radians per second,[2] although degrees per second (°/s) is also common. The radian is a dimensionless quantity, thus the SI units of angular velocity are dimensionally equivalent to reciprocal seconds, s−1, although rad/s is preferable to avoid confusion with rotation velocity in units of hertz (also equivalent to s−1).[3]

Tangential velocity

\(v=\omega r\)

v = tangential speed
r = radius
\(\omega\) = angular rate of rotation, also known as angular velocity

\(v=\frac {2\pi r}{T}\)

v = tangential speed
r = radius
T = period for one rotation

Code

water_wheel_rotation_frequency = (np.arange(5,21))*ureg.rpm

plt.plot(water_wheel_rotation_frequency.magnitude,(water_wheel_diameter/2*water_wheel_rotation_frequency.to('Hz')).to_base_units().magnitude,'-')

plt.grid()

plt.ylabel('Wheel tangential velocity, m/s')
plt.xlabel('wheel RPM')

plt.title('Wheel tangential velocity')
plt.show()

print(‘{:<15s}{:<10s}’.format(‘wheel rpm’, ‘tangential velocity’)) for i in water_wheel_rotation_frequency: print(‘{:<4.1f~P} {:<,.2f~P}’.format(i.to(‘rpm’), (water_wheel_diameter/2*i.to(‘Hz’)).to_base_units()))

Code

table_header = ['wheel rpm', 'tangential velocity, m/s']
table_row = []

for i in water_wheel_rotation_frequency:
    table_row.append([i.to('rpm').magnitude,(water_wheel_diameter/2*i.to('Hz')).to_base_units().magnitude])

print(tabulate(table_row, headers=table_header,tablefmt="simple",floatfmt=('.0f',',.2f')))

  wheel rpm    tangential velocity, m/s
-----------  --------------------------
          5                        0.55
          6                        0.66
          7                        0.77
          8                        0.88
          9                        0.99
         10                        1.10
         11                        1.21
         12                        1.32
         13                        1.43
         14                        1.54
         15                        1.65
         16                        1.76
         17                        1.87
         18                        1.98
         19                        2.09
         20                        2.20

Flume water velocity should match the tangential velocity at the flow rate.

Checking on units

turn = 2 * π * radian = _ = revolution = cycle = circle

[frequency] = 1 / [time]
hertz = 1 / second = Hz
revolutions_per_minute = revolution / minute = rpm
revolutions_per_second = revolution / second = rps
counts_per_second = count / second = cps

Rotational frequency units of SI unit Hz, Other units rpm, cps

Tangential speed Tangential speed is the speed of an object undergoing circular motion, i.e., moving along a circular path.[1] A point on the outside edge of a merry-go-round or turntable travels a greater distance in one complete rotation than a point nearer the center. Travelling a greater distance in the same time means a greater speed, and so linear speed is greater on the outer edge of a rotating object than it is closer to the axis. This speed along a circular path is known as tangential speed because the direction of motion is tangent to the circumference of the circle. For circular motion, the terms linear speed and tangential speed are used interchangeably, and both use units of m/s, km/h, and others

\(v=\frac {2\pi r}{T}\)

r = radius
T = the rotation period

Rotational frequency can be obtained dividing angular frequency, ω, by a full turn (2π radians): ν=ω/(2π rad).

Generator

There were two generators used in the project

The PM generator had low voltage and high voltage versions

Testing and building a prototype in his shop should have been done. A normal project management process that included design reviews would have required prototypes and lab or shop testing prior to the final design.

generator #1

Kris complained that the label didn’t match his observations.

3 phase permanent magnet generator

First generator is a 2kW PM generator, exact specifications are not clear. Different voltages were used. Kris was unhappy about the perforance of the 1st generator.

Based on my research, the generator is a Rewindagic generator obtained from from AliExpress, which was as far as I can tell is a 2kW, low speed permanent magnet generator, available in various voltages such as 48V, 220V, 400V. The cost in the US is $555.84.

Rewindagic generator specifications

Model: PMG-2000L
Rated power(w)	2000W
Max power(w)	2500W
Rated voltage(v)	24v-220v
Rated rotated speed(rpm)	500rpm
Start torque(<Nm)	0.74 Nm
Rated torque (<Nm)	16.4 Nm
Working temperature	-40 - 80 centigrade

Kris should have test this generator on a test stand, then mocked up the generator with the gear box and pulleys. I don’t know what he was expecting the water wheel rotational speed to be when he was doing the design, but 10 RPM at 120 lps seems about right to me. He needed a gear ratio of 10:500 or 1:50, but his inital design was a 1:20. Later he upped the gear ratio to 1:40.

Testing on a gernerator test stand, rather than on site infront of the customer, is always prefered. He would have determine if the Rewindagic generator would meet his needs.

complained about heat, thin wires,

corresponded with the supplier,

determined that many generators advertized on line are probably rate incorrectly

dertermined that the actual capabilites of the generator is likely 500 Watts sustained.

Thermal calculations

Code

H = 2.1*ureg.meter # head equal to the wheel diameter
Q = 120*ureg.liter/(1*ureg.sec)
available_power_to_generator = (rho*g*Q*H*eta_waterwheel*eta_gear_box).to('watt')
print('available power to generator: {:,.1f~P}'.format(available_power_to_generator))

available power to generator: 2,112.4 W

Assuming that the generator will convert avaliable power to electrical energy. Then losses internal to the generator will produce heat.

Code

print('generator losses as heat: {:.1f~P}'.format((available_power_to_generator*(1-eta_generator)).to('watt')))

generator losses as heat: 211.2 W

\(\large{\color {red} {\text{do heat transfer calculation to check temperature rise, get units working}}}\)

Convected heat

See heat transfer text book page 816, example 15-10

Horizontal cylinder

Simplified relation for natural convection heat transfer coefficient for a horizontal cylinder, Table 15-1 [1].

\(h_{conv}=1.32 {\frac {\Delta T}{D}}^{0.25}\)

where:
\(h_{conv}\) = heat transfer coefficient for a horizontal cylinder
\(\Delta T\) = difference in surface temperature and surrounding air \(D\) = diameter of cylinder

Heat transfer

\(Q_{conv}=h_{conv}A \Delta T\)

where:
\(Q_{conv}\) = convective heat transfer \(h_{conv}\) = heat transfer coefficient
\(A\) = area of motor case
\(\Delta T\) = surface temperature with surrounding enviroment

Referene:
1. Yunus A. Cengel, Heat Transfer: A Practical Approach, 2nd edition, McGraw-Hill, 2003

Modeling the surface area of the generator as a cylinder with hemishpere end pieces. The diameter has been increased by 25% to account for radiating fins on the case.

There is heat transfer from the case to the frame through the mounting bracket.

Code

max_allowed_gen_case_temp = 80*ureg.degC
max_ambient_temp = 38*ureg.degC
delta_T = max_allowed_gen_case_temp - max_ambient_temp

Code

D = 0.190*ureg.meter # diameter of motor case
D = D+D*0.25 # adjust the diameter by 25% to account for radiating fins on the case
L = 0.138*ureg.meter #length of motor case
A = np.pi*D*L + np.pi*D**2 # heat transfer surface of the generator (area of the cylinder plus end pieces)

Code

h_conv = 1.32*((delta_T.magnitude)/(D.magnitude))**(0.25)
Q_conv = h_conv*A.magnitude*delta_T.magnitude
print('Q_conv: {:.2f}W'.format(Q_conv))

Q_conv: 56.64W

Radiated heat

Put formula here with some narrative

\(Q_{rad}=\epsilon A_s \sigma (T_s^4 - T_{surr}^4)\)

where: \(Q_{rad}\) = radiated heat transfer between the surface at temperature \(T_s\) completely surrounded by a much larger surface at temperature \(T_{surr}\)
\(\epsilon\) = emissivity of the surface
\(A_s\) = surface area
\(\sigma\) = Stefan Boltzmann constant
\(T_s\) = surface temperature \(T_{surr}\) = surrounding temperature

Code

emissivity = 0.85
alpha = 5.67e-8 # Stefan-Blotzmann constant
Q_rad = emissivity*A.magnitude*alpha*(max_allowed_gen_case_temp.to('degK').magnitude**4-max_ambient_temp.to('degK').magnitude**4)
print('Q_rad: {:.2f}W'.format(Q_rad))

Q_rad: 83.46W

Heat conduction through base

\(Q_{cond}=\frac {\Delta T}{R}\)

where:
\(Q_{cond}\) = cinducted heat transfer between mounting feet and frame \(\Delta T\) = surface temperature with surrounding enviroment
\(R\) = thermal resistance of generator base to frame

Code

R_thermal = 10 # a guess
Q_cond = delta_T.magnitude/R_thermal
print('Q_cond: {:.2f}W'.format(Q_cond))

Q_cond: 4.20W

Total heat transfered from the generator body

Code

total_heat_out = Q_conv+Q_rad+Q_cond
print('total heat transfered from the generator body to the enviroment: {:.1f} Watts'.format(total_heat_out))

generator_losses_as_heat = (rho*g*Q*H*eta_waterwheel*eta_gear_box*(1-eta_generator)).to('watt')
print('generator losses as internal heat: {:.1f~P}'.format(generator_losses_as_heat))

print('net generator heat flow: {:.1f} Watts'.format(total_heat_out - generator_losses_as_heat.magnitude))

total heat transfered from the generator body to the enviroment: 144.3 Watts
generator losses as internal heat: 211.2 W
net generator heat flow: -66.9 Watts

Since the net heat flow is negative, the generator will heat up.

Why did the 1st generator get hot?

\(\large{\color {red} {\text{why did the 1st generator get hot?}}}\)

• inverter could have been in constant voltage mode with shaft to load power missmatch, wheel was spining too fast
• available power - displayed power = 1000 W as heat
• generator true rated power is 500 Watts, not 2000 Watts

Comments on PM generator

• needed more testing to verify Kris’s complaints about the genertor

Induction generator

The second generator tried was a 2.2kW, 8 pole, induction generator from Tec Motors. This motor need 750 rpm for make the rated power.

with the gear ratio of 1:40 and a water wheel rpm of 18, the generator shaft RPM is 720.

With the efficiencies and derating applied, I he will not get 1500 W as shown below.

Self excited induction generator (part 1)

Self excited induction generator (part 2)

generated_rated_pwr = 2200ureg.watt(720/750) generator_derating = 0.9

print(‘generator internal losses as heat: {:.1f~P}’.format(generated_rated_pwr(1-eta_generator)generator_derating))

Code

print('generator losses as heat: {:.1f~P}'.format((available_power_to_generator*(1-eta_generator)).to('watt')))

generator losses as heat: 211.2 W

same as above

\(\large{\color {red} {\text{do heat transfer calculation to check temperature rise}}}\)

\(\large{\color {red} {\text{do heat transfer calculation to check temperature rise, get units working}}}\)

Convected heat

Code

D = 0.252*ureg.meter # diameter of motor case
D = D+D*0.25 # adjust the diameter by 25% to account for radiating fins on the case
L = 0.229*ureg.meter #length of motor case
A = np.pi*D*L + np.pi*D**2 # heat transfer surface of the generator (area of the cylinder plus end pieces)

Code

h_conv = 1.32*((delta_T.magnitude)/(D.magnitude))**(0.25)
Q_conv = h_conv*A.magnitude*delta_T.magnitude
print('Q_conv: {:.2f}W'.format(Q_conv))

Q_conv: 101.42W

Radiated heat

Code

emissivity = 0.85
alpha = 5.67e-8 # Stefan-Blotzmann constant
Q_rad = emissivity*A.magnitude*alpha*(max_allowed_gen_case_temp.to('degK').magnitude**4-max_ambient_temp.to('degK').magnitude**4)
print('Q_rad: {:.2f}W'.format(Q_rad))

Q_rad: 160.36W

Heat conduction through base

Code

R_thermal = 10 # a guess
Q_cond = delta_T.magnitude/R_thermal
print('Q_cond: {:.2f}W'.format(Q_cond))

Q_cond: 4.20W

Total heat transfered from the generator body

Code

total_heat_out = Q_conv+Q_rad+Q_cond
print('total heat transfered from the generator body to the enviroment: {:.1f} Watts'.format(total_heat_out))

generator_losses_as_heat = (rho*g*Q*H*eta_waterwheel*eta_gear_box*(1-eta_generator)).to('watt')
print('generator losses as internal heat: {:.1f~P}'.format(generator_losses_as_heat))

print('net generator heat flow: {:.1f} Watts'.format(total_heat_out - generator_losses_as_heat.magnitude))

total heat transfered from the generator body to the enviroment: 266.0 Watts
generator losses as internal heat: 211.2 W
net generator heat flow: 54.7 Watts

The net heat transfer is rate is positive so OK.

In addition to not makeing 1500 W, he needs a new gear box with a ratio of 10:750 or 1:75.

Comments about the induction genertor

• needed higher power rating
  
• need higher gear ratio

Generator selection critieria

• rpm
  
• generator rated power vs available power
  
• induction generator capacitor selection
  
• pros and cons of induction generator

\(\large{\color {red} {\text{Replot the power curve intercestion for the induction generator, RPM is different}}}\)

Code

step_size = 20
Q = np.arange(60, 180+step_size, step_size)*ureg.liter/(1*ureg.sec)

#water_wheel_rotation_frequency = (np.arange(5,21))*ureg.rpm
water_wheel_rotation_frequency = (np.linspace(5,20,100))*ureg.rpm
i = 0 #for i in range(len(Q)):

water_wheel_shaft_torque = np.zeros(len(water_wheel_rotation_frequency))*ureg.kilogram*ureg.g0*ureg.meter
available_pwr = np.zeros(len(water_wheel_rotation_frequency))*ureg.watt
load_pwr = np.zeros(len(water_wheel_rotation_frequency))*ureg.watt

for j in range(len(water_wheel_rotation_frequency)):
    water_transport_rate = (number_of_buckets*bucket_volume*water_wheel_rotation_frequency[j]).to('liter/sec')

    bucket_capacity_utilization = Q[i]/water_transport_rate

    # limit transport rate to flow rate
    if bucket_capacity_utilization > 1:
        bucket_capacity_utilization = 1
        water_transport_rate = Q[i]

    weight_of_water_per_bucket = (rho*bucket_volume)*bucket_capacity_utilization

    torque_per_bucket = (weight_of_water_per_bucket*ureg.g0*moment_arm).to_base_units()
    water_wheel_shaft_torque[j] = torque_per_bucket.sum()    

    available_pwr[j] = (water_wheel_shaft_torque[j]*water_wheel_rotation_frequency[j]*eta_waterwheel)
    load_volts = (220/750)*water_wheel_rotation_frequency[j].magnitude*gear_box*ureg.volt
    load_current = load_volts/R_load
    load_pwr[j] = R_load*load_current**2
    
plt.plot(water_wheel_rotation_frequency.magnitude,available_pwr.to('watts').magnitude,'-',label='available pwr')
plt.plot(water_wheel_rotation_frequency.magnitude,load_pwr.to('watts').magnitude,'-',label='load pwr')  

idx = np.argwhere(np.diff(np.sign(load_pwr.to('watts').magnitude - available_pwr.to('watts').magnitude))).flatten()
plt.plot(water_wheel_rotation_frequency.magnitude[idx],load_pwr.to('watts').magnitude[idx], 'ro')
plt.plot(water_wheel_rotation_frequency.magnitude[idx],available_pwr.to('watts').magnitude[idx], 'kx')

plt.grid()

plt.ylabel('power, Watts')
plt.xlabel('wheel rpm')

plt.title('available power from water wheel, power to R_load = {:.1f~P} @ flow = {:.1f~P}'.format(R_load,Q[i]))
plt.legend(loc=0)

plt.show()

print('the curves intersect at {:.1f} rpm and {:.1f} W'.format(float(water_wheel_rotation_frequency.magnitude[idx]),float(load_pwr.to('watts').magnitude[idx])))

the curves intersect at 14.8 rpm and 940.7 W

The flow rate need to be lowered for the cureves to intersect and to keep the wheel RPM reasonable.

The gear box ratio need to be

Code

750/10

75.0

The flume

The flume carries water from the dam to the top of the waterwheel. By examining the videos, I made some estimates for the flume dimensions.

The width of the flume was about the same width of the waterwheel, which makes sense, since you want a nice flow of water into the buckets.

The side walls of the flume looked like 2 by 6 inch boards. The depth of the water in the channel looks like a maximum of 5 inches of flow. Also, the buckets need to handle what ever the flow rate is. Need to look at the RPM.

I can use the Manning equation for open channel flow to calculate the flow rate in the flume. Mannings equation is an empirical equation that applies to uniform flow in open channels and is a function of the channel velocity, flow area and channel slope.

\(V = \frac {s^{1/2} \times R^{2/3}} {n}\)

where:

V - water velocity
n - Manning’s roughness coefficient; unplaned wood = 0.013, wood sides and smooth sheet metal bottom
R - The channel’s hydraulic radius, calculated by dividing the water flow’s cross-sectional area A by its wetted perimeter P
s - Slope of the channel’s bottom surface

Examining Manning’s equation, we can see that the area and slope are directly proportional to the water flow rate, which means an increase in area and slope would increase the water flow rate. On the other hand, the roughness coefficient and the wetted perimeter are inversely proportional to the water flow rate, meaning that increasing their values would decrease the water flow rate.

The slope of the flume was not apparent in any of the videos, so I’m using a value of 0.01.

\(\large{\color {red} {\text{get some screen shots of the flume}}}\)

Flume slope

This does not agree with the text, which states: > Because this has to be quite long (approximately 8 meters) there needs to be a downward slope in order to keep the water flowing. I have made this slope 1 degree and it equates to a 300mm level change.

Code

flume_length = 8*ureg.meter
flume_drop = 300*ureg.mm
flume_drop.ito('meter')

np.arctan(flume_drop/flume_length).to('degree')

2.147585428298503 degree

The math works out to about 2 degrees.

So which is it, 1 degree or 300mm drop?

Code

flume_slope = flume_drop.magnitude/flume_length.magnitude
flume_slope

0.0375

Code

flume_width = 800*ureg.mm
water_depth = 70*ureg.mm # estimate
# convert to base units
flume_width.ito('meter')
water_depth.ito('meter')
water_cross_section_area = water_depth*flume_width
print('water_cross_section_area = {:.4f~P}'.format(water_cross_section_area))
wetted_perimeter = 2*water_depth+flume_width
print('wetted_perimeter = {:.4f~P}'.format(wetted_perimeter))
hydraulic_radius = water_cross_section_area/wetted_perimeter
print('hydraulic_radius = {:.4f~P}'.format(hydraulic_radius))
roughness_coefficient = 0.013 # Wood - unplaned
slope = flume_slope #0.0025
print('slope = {:.4f}'.format(slope))
# need to use magnitude of quantity when using fractional exponents
water_flume_velocity = (((hydraulic_radius.magnitude)**(2/3)*slope**(1/2))/roughness_coefficient)*ureg.meter/ureg.sec
print('water_flume_velocity = {:.4f~P}'.format(water_flume_velocity))
volumetric_flow_rate = water_flume_velocity*water_cross_section_area
print('volumetric_flow_rate = {:.6f~P}'.format(volumetric_flow_rate))
print('volumetric_flow_rate = {:.2f~P}'.format(volumetric_flow_rate.to('liter/sec')))

water_cross_section_area = 0.0560 m²
wetted_perimeter = 0.9400 m
hydraulic_radius = 0.0596 m
slope = 0.0375
water_flume_velocity = 2.2722 m/s
volumetric_flow_rate = 0.127243 m³/s
volumetric_flow_rate = 127.24 l/s

Think about working the problem in reverse: the water wheel is rotating at 10 rpm, which is about 115 lps of flow rate consumed by the water wheel.

The flume water velocity should match the wheel tangential velocity at flow rate of 115 lps.

\(\large{\color {red} {\text{Find a spot in the videos where the depth in the flume can be estimated and where he shows the power}}}\)

does he also say bucket fill level?

Flume re-design

spillway baffles

In this study, a two-dimensional physical model was used to evaluate the effectiveness of adding baffles and sills at step edges or of shifting them from step edges of a 1V:1H sloping, short, sharp- or round-crested stepped spillway with an ogee inlet. A comparison between different configurations of baffles and sills was carried out with respect to the energy dissipation and the flow characteristics. The baffle-shifted round-crested spillway gives the smallest discharge required for the onset of a skimming flow among all other configurations. The baffle-edged chute dissipates more energy than the sill-edged spillway. Shifting baffles or sills from the sharp edges decreases the energy dissipation. Shifting baffles or sills from the round-crested spillway increases the energy dissipation in the range of the discharges studied. Empirical equations for energy dissipation are introduced for practical application of spillways of comparable similar conditions.

Four general aspects of spillways are worth noting. First, the uncontrolled discharge of surplus water past the dam should be automatic and not dependent upon human control. Second, the spillway intake should be wide enough so that the largest floods can pass without increasing the water level in the reservoir enough to cause a nuisance to upstream property owners. Third, the rate of floodwater discharge should not increase much above that experienced before the construction of the dam. An increase in discharge can cause flood problems downstream, but a dam usually reduces the peak discharge rate because of the lag effect caused by a flood passing through the reservoir. Fourth, floodwater discharged over the height of a dam can be destructive to the dam structure itself and to the riverbed unless its energy is controlled and dissipated in harmless turbulence.

HYDRAULIC INVESTIGATIONS 1T ~~ 4) AND LABORATORY SERVICES OFFICIAL FILE COPY A BAFFLED APRON AS A SPILLWAY ENERGY DISSIPATOR

Code

flume_width = 800*ureg.mm
water_depth = 200*ureg.mm
# convert to base units
flume_width.ito('meter')
water_depth.ito('meter')
water_cross_section_area = water_depth*flume_width
print('water_cross_section_area = {:.4f~P}'.format(water_cross_section_area))
wetted_perimeter = 2*water_depth+flume_width
print('wetted_perimeter = {:.4f~P}'.format(wetted_perimeter))
hydraulic_radius = water_cross_section_area/wetted_perimeter
print('hydraulic_radius = {:.4f~P}'.format(hydraulic_radius))
roughness_coefficient = 0.013 # Wood - unplaned
slope = 0.0025
print('slope = {:.4f}'.format(slope))
# need to use magnitude of quantity when using fractional exponents
water_flume_velocity = (((hydraulic_radius.magnitude)**(2/3)*slope**(1/2))/roughness_coefficient)*ureg.meter/ureg.sec
print('water_flume_velocity = {:.4f~P}'.format(water_flume_velocity))
volumetric_flow_rate = water_flume_velocity*water_cross_section_area
print('volumetric_flow_rate = {:.6f~P}'.format(volumetric_flow_rate))
print('volumetric_flow_rate = {:.2f~P}'.format(volumetric_flow_rate.to('liter/sec')))

water_cross_section_area = 0.1600 m²
wetted_perimeter = 1.2000 m
hydraulic_radius = 0.1333 m
slope = 0.0025
water_flume_velocity = 1.0038 m/s
volumetric_flow_rate = 0.160610 m³/s
volumetric_flow_rate = 160.61 l/s

safety

• flood and spill way
  • river level monitoring and alearts
  • leat and it’s wears
• gounding
• failures
  • safety instrumentation

maintenance

• wet environment

Economic analysis

This project was done in the UK, but now I’m switching to my local cost of electricity and currency in USD. Assume that the house or property uses 400 Watts average.

I pay 32 cents per kWh if I stay below 11.4 kWh per day

includes generating cost, delivery costs and goverment fees and taxes. I could pay more if I wanted my power classified as ‘green power’.

The electrical rate is $0.35 per kWh. The daily and yearily electrical costs are as follows:

Code

house_pwr_usage = 400*ureg.watt
meter_rate = 0.32/(1000*ureg.Wh)
print('house daily energy usage: {:,.0f~P}'.format((24*ureg.hr*house_pwr_usage).to('Wh')))
print('house daily energy usage cost: ${:.2f}'.format((24*ureg.hr*house_pwr_usage*meter_rate).to_base_units().magnitude))
house_yearly_energy_usage_cost = 365*24*ureg.hr*house_pwr_usage*meter_rate
print('house yearly energy usage cost: ${:,.2f}'.format(house_yearly_energy_usage_cost.to_base_units().magnitude))

house daily energy usage: 9,600 Wh
house daily energy usage cost: $3.07
house yearly energy usage cost: $1,121.28

Since the water wheel is generating more power than needed, the cost saved per year is equal to the cost of electrical energy consumed.

Code

saved_cost_yr = house_yearly_energy_usage_cost
print('cost saved per year: ${:,.2f}'.format(saved_cost_yr.to_base_units().magnitude))

cost saved per year: $1,121.28

The net energy used per day is the generated energy per day minus the daily energy usage.

Code

generated_pwr = 1500*ureg.watts
net_pwr_usage = generated_pwr - house_pwr_usage
net_energy_day = 24*ureg.hour*net_pwr_usage
print('net energy per day: {:,.0f~P}'.format(net_energy_day))

net energy per day: 26,400 W·h

As an example, Southern California Edison (SCE) has a Net Surplus Compensation Rate (NSCR) that compensates Net Energy Metering (NEM) customers for electricity they produce in excess of their on-site load over the course of a 12-month period, referred to as the “Relevant Period.” NEM customers who produce excess power over their Relevant Period are known as Net Surplus Generators. NSCR is calculated using a market-based mechanism derived from an hourly day-ahead electricity market price known as the Default Load Aggregation Point (DLAP) price. Southern California Edison’s DLAP price reflects the costs SCE avoids in procuring power during the time period Net Surplus Generators are likely to produce excess power with their solar or wind generating facilities.

NSCR Energy Prices

For Relevant Period Ending	NSCR Energy ($/kWh)
January 2024	0.04696
December 2023	0.05881
November 2023	0.06030
October 2023	0.06268
September 2023	0.06818
August 2023	0.07009
July 2023	0.07224
June 2023	0.07512
May 2023	0.07712
April 2023	0.07778
March 2023	0.07494
February 2023	0.07276
January 2023	0.06212

The average NSCR for the trailing 12 months is calculated below

Code

avg_net_meter_rate = np.array([0.04696,0.05881,0.06030,0.06268,0.06818,0.07009,0.07224,0.07512,0.07712,0.07778,0.07494,0.07276,0.06212]).mean()
print('the average net meter rate for the trailing 12 months: {:.2} per kWh'.format(avg_net_meter_rate))

the average net meter rate for the trailing 12 months: 0.068 per kWh

Code

net_meter_rate = avg_net_meter_rate/((1000*ureg.Wh)) # amount per kWh
#net_meter_rate = 0.15/((1000*ureg.Wh)) # amount per kWh
print('net meter rate: ${:.2f} per kWh'.format(net_meter_rate.magnitude*1000))
print('Net meter credit: ${:,.2f} per day'.format((net_energy_day*net_meter_rate).to_base_units().magnitude))
net_meter_credit_yr = (365*net_energy_day*net_meter_rate).to_base_units()
print('Net meter credit: ${:,.2f} per year'.format(net_meter_credit_yr.magnitude))

net meter rate: $0.07 per kWh
Net meter credit: $1.79 per day
Net meter credit: $651.62 per year

The cost of construction for the dam, spillway and water wheel is estimated to be $20,000. But this is just a guess since Kris didn’t share any financial innformation.

The maintence cost per year is estimated to be $200.

The project life is estimated to be 15 years. This is the time frame that the internal rate of return will be calculated for. The internal rate of return is a method of quantifying the merits of a project or investment opportunity. The calculation is termed internal because it depends only on the cash flows of the investment being analyzed and excludes external factors, such as returns available elsewhere, the risk-free rate, inflation, the cost of capital, or financial risk.

Code

construction_cost = 20000 # who knows?
maintenance_cost = 200 # per year
#net_meter_credit_per_year = (365*generator_energy*net_meter_rate).to_base_units().magnitude
project_life = 15 # years

cash_flow_each_year = np.ones(project_life)*(saved_cost_yr+net_meter_credit_yr-maintenance_cost).magnitude

# include construction cost in 1st year
cash_flow_each_year[0] = cash_flow_each_year[0]-construction_cost
#cash_flow_each_year

Code

def irr(values, guess=None, tol=1e-12, maxiter=100):
    """
    Return the Internal Rate of Return (IRR).
    This is the "average" periodically compounded rate of return
    that gives a net present value of 0.0; for a more complete explanation,
    see Notes below.
    :class:`decimal.Decimal` type is not supported.
    Parameters
    ----------
    values : array_like, shape(N,)
        Input cash flows per time period.  By convention, net "deposits"
        are negative and net "withdrawals" are positive.  Thus, for
        example, at least the first element of `values`, which represents
        the initial investment, will typically be negative.
    guess : float, optional
        Initial guess of the IRR for the iterative solver. If no guess is
        given an heuristic is used to estimate the guess through the ratio of
        positive to negative cash lows
    tol : float, optional
        Required tolerance to accept solution. Default is 1e-12.
    maxiter : int, optional
        Maximum iterations to perform in finding a solution. Default is 100.
    Returns
    -------
    out : float
        Internal Rate of Return for periodic input values.
    """
    values = np.atleast_1d(values)
    if values.ndim != 1:
        raise ValueError("Cashflows must be a rank-1 array")

    # If all values are of the same sign no solution exists
    # we don't perform any further calculations and exit early
    same_sign = np.all(values > 0) if values[0] > 0 else np.all(values < 0)
    if same_sign:
        return np.nan

    # If no value is passed for `guess`, then make a heuristic estimate
    if guess is None:
        positive_cashflow = values > 0
        inflow = values.sum(where=positive_cashflow)
        outflow = -values.sum(where=~positive_cashflow)
        guess = inflow / outflow - 1

    npv_ = np.polynomial.Polynomial(values[::-1])
    d_npv = npv_.deriv()
    g = 1 + guess

    for _ in range(maxiter):
        delta = npv_(g) / d_npv(g)
        if abs(delta) < tol:
            return g - 1
        g -= delta

    return np.nan

The internal rate of return is calculated and shown below.

Code

print('internal rate of return: {:.1f}%'.format(irr(cash_flow_each_year)*100))

internal rate of return: 2.5%

This rate of return is very small and indicates that the funds spent on the construction might be better used elsewhere. The low IRR is primarily driven by two factors, the low net meter rate and the average Watts used. The low IRR also indicates that this hydro system probably should not be grid tied and only makes sense for true off grid situations.

If the house uses uses all the hydro power, then the IRR is favorable.

Summary

• generator not thourally tested in the shop, just an OC test
• flume design too steep
• gear ratio too low for final generator